package weiyao.xinxidasai.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import weiyao.xinxidasai.DTO.FileTreeNode;
import weiyao.xinxidasai.mapper.FilesMapper;
import weiyao.xinxidasai.mapper.FolderMapper;
import weiyao.xinxidasai.pojo.FFiles;
import weiyao.xinxidasai.pojo.FilesFolder;


import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class FileSystemService {
    @Autowired
    private FolderMapper folderMapper;

    @Autowired
    private FilesMapper fileMapper;



    public FileTreeNode getUserFileTree(Long userId) {
        // 1. 获取所有文件夹和文件
        List<FilesFolder> folders = folderMapper.findFolderByUserId(userId);
        List<FFiles> files = fileMapper.findByUserId(userId);

        // 2. 查找根路径文件夹（空路径）
        FilesFolder rootFolder = null;
        for (FilesFolder folder : folders) {
            if (folder.getFolderPath() == null || folder.getFolderPath().isEmpty()) {
                rootFolder = folder;
                break;
            }
        }

        // 3. 创建根节点（使用数据库中的根路径文件夹）
        FileTreeNode root;
        if (rootFolder != null) {
            root = new FileTreeNode(rootFolder.getFolderId(), "根目录", "folder", "/");
        } else {
            // 如果数据库中没有根路径，创建虚拟根节点
            root = new FileTreeNode(0L, "根目录", "folder", "/");
        }

        // 4. 构建文件夹映射表 (path -> node) 和 ID映射表 (folderId -> path)
        Map<String, FileTreeNode> folderMap = new HashMap<>();
        Map<Long, String> folderIdToPathMap = new HashMap<>();

        folderMap.put("/", root);
        folderIdToPathMap.put(root.getId(), "/"); // 根节点ID映射

        // 5. 按路径层级排序（确保父文件夹先处理）
        folders.sort(Comparator.comparing(f -> {
            String path = f.getFolderPath();
            if (path == null || path.isEmpty()) return 0; // 根路径排在最前
            return path.split("/").length;
        }));

        // 6. 构建文件夹树（跳过根路径文件夹，因为已创建根节点）
        for (FilesFolder folder : folders) {
            // 跳过根路径文件夹（已处理）
            if (folder == rootFolder) continue;

            String path = folder.getFolderPath();
            // 处理空路径（理论上不应该出现多个空路径）
            if (path == null || path.isEmpty()) {
                path = "/";
            }

            String parentPath = getParentPath(path);

            FileTreeNode node = new FileTreeNode(
                    folder.getFolderId(),
                    extractFolderName(path),
                    "folder",
                    path
            );

            // 添加到父节点
            if (folderMap.containsKey(parentPath)) {
                folderMap.get(parentPath).getChildren().add(node);
            } else {
                // 找不到父路径时挂到根目录
                root.getChildren().add(node);
            }

            folderMap.put(path, node);
            folderIdToPathMap.put(folder.getFolderId(), path);
        }

        // 7. 添加文件到对应文件夹
        for (FFiles file : files) {
            System.out.println("file = " + file.getFileType());
            // 获取文件所属文件夹路径
            String folderPath;
            if (file.getFolderId() == null) {
                // 没有文件夹ID的文件属于根目录
                folderPath = "/";
            } else {
                // 使用ID映射获取文件夹路径
                folderPath = folderIdToPathMap.get(file.getFolderId());
                if (folderPath == null) {
                    // 找不到映射时使用根目录
                    folderPath = "/";
                }
            }

            if (folderMap.containsKey(folderPath)) {
                FileTreeNode fileNode = new FileTreeNode(
                        file.getFilesId(), // 确保类型匹配（Long）
                        file.getDisplayName(),
                        "file",
                        folderPath + "/" + file.getDisplayName()
                );
                fileNode.setSize(file.getFileSize());
                fileNode.setUploadTime(file.getUploadTime());
                 fileNode.setFilesLock(file.getFilesLock());
                 fileNode.setFileType(file.getFileType());
                 fileNode.setFilesLockType(filesLockTypes(file));
                folderMap.get(folderPath).getChildren().add(fileNode);
            }
        }

        return root;
    }

    private String filesLockTypes(FFiles file) {
        FFiles fileById = fileMapper.getFileById(file.getFilesId());
        // 同时处理 null 和空字符串的情况
        if (fileById.getFilesLock() == 1 &&
                (fileById.getFilesPassword() == null || fileById.getFilesPassword().isEmpty())) {
            return "Face";
        }if (fileById.getFilesLock()==1&&fileById.getFilesPassword()!=null) {   return "Password";}
     return null;
    }

    // 辅助方法：获取父路径
    private String getParentPath(String path) {
        if (path == null || path.equals("/")) return "/";

        // 规范化路径（去除结尾斜杠）
        String normalized = path.endsWith("/") ?
                path.substring(0, path.length() - 1) : path;

        int lastSlash = normalized.lastIndexOf('/');
        if (lastSlash <= 0) return "/";

        return normalized.substring(0, lastSlash);
    }

    // 辅助方法：从路径提取文件夹名称
    private String extractFolderName(String path) {
        if (path == null || path.isEmpty() || path.equals("/")) {
            return "根目录";
        }

        // 规范化路径（去除结尾斜杠）
        String normalized = path.endsWith("/") ?
                path.substring(0, path.length() - 1) : path;

        int lastSlash = normalized.lastIndexOf('/');
        return lastSlash >= 0 ?
                normalized.substring(lastSlash + 1) : normalized;
    }

}